package ThreadTest;

/**
 * Created with IntelliJ IDEA.
 * Description:
 * User:周次煜
 * Date: 2024-07-15
 * Time：17:25
 */


/**
 * 创建线程
 * 方法一： 继承 Thread ， 重写 run 方法
 *
 * 步骤： 1.定义一个专有的类来继承 Tread
 * 2. 重写这个 run  方法
 * 3. 在main 中new 一个对象，然后使用 start 这个方法
 * 4.  start 方法不仅可以 创建线程， 而且这个回调 重写的这个 run 方法
 *
 */
public class MyThread extends Thread{
    @Override
    public void run() {
        while(true) {
            System.out.println("Thread->run方法正在运行...");

            /*
            因为sleep 会抛出异常
            并且这个异常是不允许直接向下抛出的
            否则会重写的方法不一致
             */

            try {
                sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
            // 创建MyThread对象
            MyThread myThread = new MyThread();

            // 创建线程
//               同时调用 run 执行
//        这个一种回调函数的特性
            myThread.start();


            while (true) {
                System.out.println("main方法正在运行...");
                sleep(1000);
            }




    }
}


/**
 * 创建线程
 * 方法二： 实现 Runnable ， 重写 run
 * 步骤： 1.定义一个类 实现 Runnable 接口
 * 2， 重写 run 方法
 * 3. 在创建 Thread 对象时， 同时 new 一个自己的类对象作为参数传入进去
 * 4. 最后 调用 start 方法， 创建线程，回调 run方法。
 */

class  MyThread1 implements   Runnable {

    @Override
    public void run() {
        while(true) {
            try {
                MyThread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("Runnable-> run 正在运行...");
        }
    }


    public static void main(String[] args) throws InterruptedException {

//        把 实现 Runnable 这个方法放入 thread 中
       Thread thread = new Thread(new MyThread1());

        // 创建线程
       thread.start();

        while (true) {
            System.out.println("main方法正在运行...");
            MyThread.sleep(1000);
        }

    }
}


/**
 * 创建线程
 * 方法三： 实现 Runnable ，重写 run ， 使用匿名内部类
 * 1. 在 main 中 实例化 Thread 对象
 * 2. 利用匿名内部类 重写 Runnable 并且实现我们方法作为参数
 * 3.  最后 调用  start ， 创建线程，回调重写的 run 方法
 */


class  MyThread2 {
    public static void main(String[] args) throws InterruptedException {

//        利用匿名内部类实现 Runnable 实现接口
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
               while (true) {
                   try {
                       MyThread.sleep(1000);
                       System.out.println("匿名内部类 Runnable -> run 正在运行... ");
                   } catch (InterruptedException e) {
                       throw new RuntimeException(e);
                   }
               }
            }
        });

        thread.start();


        while (true) {
            System.out.println("main方法正在运行...");
            MyThread.sleep(1000);
        }
    }
}


/**
 * 创建线程
 * 方法三： 继承 Thread ,重写 run ， 使用匿名内部类
 *  在原来的基础上 Thread{} 后加上方法体
 *  最后调用
 */

class  MyThread3{

    public static void main(String[] args) throws InterruptedException {
           Thread myThread3 = new Thread() {
               @Override
               public void run() {
                   while (true) {
                       try {
                           sleep(1000);
                       } catch (InterruptedException e) {
                           throw new RuntimeException(e);
                       }
                       System.out.println("run 方法正在运行...");
                   }
               }
           };

        myThread3.start();

        while (true) {
            System.out.println("main方法正在运行...");
            MyThread.sleep(1000);
        }
    }

}


/**
 *
 * 创建线程
 *
 * 方法五：
 *  使用 lambda 表达式进行简化
 *
 *  省略所有的方法名 ()
 *  利用 -> 连接
 *  用 {} 直接写方法体
 *
 *  其他调用一致
 */


class  MyThread4  {
    public static void main(String[] args) throws InterruptedException {

        // lambda 实现 表达式
        Thread thread = new Thread(() -> {while (true) {
            try {
                Thread.sleep(1000);
                System.out.println("lambda 实现 Runnable ->  run 方法正在运行...");
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
        } );

//        创建线程
        thread.start();

        while (true) {
            System.out.println("main方法正在运行...");
            MyThread.sleep(1000);
        }
    }
}


